home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / h / vd2 / plugin / vdvideofiltold.h < prev    next >
Encoding:
C/C++ Source or Header  |  2007-10-13  |  11.0 KB  |  366 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    Copyright (C) 1998-2001 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #ifndef f_VD2_PLUGIN_VDVIDEOFILTOLD_H
  19. #define f_VD2_PLUGIN_VDVIDEOFILTOLD_H
  20.  
  21. #include <stddef.h>
  22. #include <windows.h>
  23.  
  24. // Copied from <vd2/system/vdtypes.h>.  Must be in sync.
  25.  
  26. #ifndef VD_STANDARD_TYPES_DECLARED
  27.     #if defined(_MSC_VER)
  28.         typedef signed __int64        sint64;
  29.         typedef unsigned __int64    uint64;
  30.     #elif defined(__GNUC__)
  31.         typedef signed long long    sint64;
  32.         typedef unsigned long long    uint64;
  33.     #endif
  34.     typedef signed int            sint32;
  35.     typedef unsigned int        uint32;
  36.     typedef signed short        sint16;
  37.     typedef unsigned short        uint16;
  38.     typedef signed char            sint8;
  39.     typedef unsigned char        uint8;
  40.  
  41.     typedef sint64                int64;
  42.     typedef sint32                int32;
  43.     typedef sint16                int16;
  44.     typedef sint8                int8;
  45. #endif
  46.  
  47. //////////////////
  48.  
  49. struct CScriptObject;
  50.  
  51. struct FilterVTbls {
  52.     void *pvtblVBitmap;
  53. };
  54.  
  55. #ifdef VDEXT_MAIN
  56. struct FilterVTbls g_vtbls;
  57. #elif defined(VDEXT_NOTMAIN)
  58. extern struct FilterVTbls g_vtbls;
  59. #endif
  60.  
  61. //////////////////
  62.  
  63. enum {
  64.     FILTERPARAM_SWAP_BUFFERS    = 0x00000001L,
  65.     FILTERPARAM_NEEDS_LAST        = 0x00000002L,
  66. };
  67.  
  68. #define FILTERPARAM_HAS_LAG(frames) ((int)(frames) << 16)
  69.  
  70. ///////////////////
  71.  
  72. class VFBitmap;
  73. class FilterActivation;
  74. struct FilterFunctions;
  75.  
  76. typedef int  (*FilterInitProc     )(FilterActivation *fa, const FilterFunctions *ff);
  77. typedef void (*FilterDeinitProc   )(FilterActivation *fa, const FilterFunctions *ff);
  78. typedef int  (*FilterRunProc      )(const FilterActivation *fa, const FilterFunctions *ff);
  79. typedef long (*FilterParamProc    )(FilterActivation *fa, const FilterFunctions *ff);
  80. typedef int  (*FilterConfigProc   )(FilterActivation *fa, const FilterFunctions *ff, HWND hWnd);
  81. typedef void (*FilterStringProc   )(const FilterActivation *fa, const FilterFunctions *ff, char *buf);
  82. typedef int  (*FilterStartProc    )(FilterActivation *fa, const FilterFunctions *ff);
  83. typedef int  (*FilterEndProc      )(FilterActivation *fa, const FilterFunctions *ff);
  84. typedef bool (*FilterScriptStrProc)(FilterActivation *fa, const FilterFunctions *, char *, int);
  85. typedef void (*FilterStringProc2  )(const FilterActivation *fa, const FilterFunctions *ff, char *buf, int maxlen);
  86. typedef int  (*FilterSerialize    )(FilterActivation *fa, const FilterFunctions *ff, char *buf, int maxbuf);
  87. typedef void (*FilterDeserialize  )(FilterActivation *fa, const FilterFunctions *ff, const char *buf, int maxbuf);
  88. typedef void (*FilterCopy         )(FilterActivation *fa, const FilterFunctions *ff, void *dst);
  89.  
  90. typedef int (__cdecl *FilterModuleInitProc)(struct FilterModule *fm, const FilterFunctions *ff, int& vdfd_ver, int& vdfd_compat);
  91. typedef void (__cdecl *FilterModuleDeinitProc)(struct FilterModule *fm, const FilterFunctions *ff);
  92.  
  93. //////////
  94.  
  95. typedef void (__cdecl *FilterPreviewButtonCallback)(bool fNewState, void *pData);
  96. typedef void (__cdecl *FilterPreviewSampleCallback)(VFBitmap *, long lFrame, long lCount, void *pData);
  97.  
  98. class IVDFilterPreview {
  99. public:
  100.     virtual void SetButtonCallback(FilterPreviewButtonCallback, void *)=0;
  101.     virtual void SetSampleCallback(FilterPreviewSampleCallback, void *)=0;
  102.  
  103.     virtual bool isPreviewEnabled()=0;
  104.     virtual void Toggle(HWND)=0;
  105.     virtual void Display(HWND, bool)=0;
  106.     virtual void RedoFrame()=0;
  107.     virtual void RedoSystem()=0;
  108.     virtual void UndoSystem()=0;
  109.     virtual void InitButton(HWND)=0;
  110.     virtual void Close()=0;
  111.     virtual bool SampleCurrentFrame()=0;
  112.     virtual long SampleFrames()=0;
  113. };
  114.  
  115. class IVDFilterPreview2 : public IVDFilterPreview {
  116. public:
  117.     virtual bool IsPreviewDisplayed() = 0;
  118. };
  119.  
  120. typedef IVDFilterPreview IFilterPreview;        // for compatibility
  121.  
  122. //////////
  123.  
  124. #define VIRTUALDUB_FILTERDEF_VERSION        (11)
  125. #define    VIRTUALDUB_FILTERDEF_COMPATIBLE        (4)
  126.  
  127. // v3: added lCurrentSourceFrame to FrameStateInfo
  128. // v4 (1.2): lots of additions (VirtualDub 1.2)
  129. // v5 (1.3d): lots of bugfixes - stretchblt bilinear, and non-zero startproc
  130. // v6 (1.4): added error handling functions
  131. // v7 (1.4d): added frame lag, exception handling
  132. // v8 (1.4.11): added string2 proc
  133. // v9 (1.4.12): added (working) copy constructor
  134. // v10 (1.5.10): added preview flag
  135. // v11 (1.7.0): guaranteed src structure setup before configProc; added IVDFilterPreview2
  136.  
  137. typedef struct FilterModule {
  138.     struct FilterModule *next, *prev;
  139.     HINSTANCE                hInstModule;
  140.     FilterModuleInitProc    initProc;
  141.     FilterModuleDeinitProc    deinitProc;
  142. } FilterModule;
  143.  
  144. typedef struct FilterDefinition {
  145.  
  146.     struct FilterDefinition *next, *prev;
  147.     FilterModule *module;
  148.  
  149.     const char *        name;
  150.     const char *        desc;
  151.     const char *        maker;
  152.     void *                private_data;
  153.     int                    inst_data_size;
  154.  
  155.     FilterInitProc        initProc;
  156.     FilterDeinitProc    deinitProc;
  157.     FilterRunProc        runProc;
  158.     FilterParamProc        paramProc;
  159.     FilterConfigProc    configProc;
  160.     FilterStringProc    stringProc;
  161.     FilterStartProc        startProc;
  162.     FilterEndProc        endProc;
  163.  
  164.     CScriptObject    *script_obj;
  165.  
  166.     FilterScriptStrProc    fssProc;
  167.  
  168.     // NEW - 1.4.11
  169.     FilterStringProc2    stringProc2;
  170.     FilterSerialize        serializeProc;
  171.     FilterDeserialize    deserializeProc;
  172.     FilterCopy            copyProc;
  173. } FilterDefinition;
  174.  
  175. //////////
  176.  
  177. // FilterStateInfo: contains dynamic info about file being processed
  178.  
  179. class FilterStateInfo {
  180. public:
  181.     long    lCurrentFrame;                // current output frame
  182.     long    lMicrosecsPerFrame;            // microseconds per output frame
  183.     long    lCurrentSourceFrame;        // current source frame
  184.     long    lMicrosecsPerSrcFrame;        // microseconds per source frame
  185.     long    lSourceFrameMS;                // source frame timestamp
  186.     long    lDestFrameMS;                // output frame timestamp
  187.  
  188.     enum {
  189.         kStateNone        = 0x00000000,
  190.         kStatePreview    = 0x00000001,    // (V1.5.10+) Job output is not being saved to disk.
  191.         kStateRealTime    = 0x00000002,    // (V1.5.10+) Operation is running in real-time (capture, playback).
  192.         kStateMax        = 0xFFFFFFFF
  193.     };
  194.  
  195.     long    flags;
  196. };
  197.  
  198. // VFBitmap: VBitmap extended to hold filter-specific information
  199.  
  200. class VFBitmap {
  201. public:
  202.     void *_vtable;
  203.     uint32 *        data;
  204.     uint32 *        palette;
  205.     int                depth;
  206.     sint32            w, h;
  207.     ptrdiff_t        pitch;
  208.     ptrdiff_t        modulo;
  209.     ptrdiff_t        size;
  210.     ptrdiff_t        offset;
  211.  
  212.     enum {
  213.         NEEDS_HDC        = 0x00000001L,
  214.     };
  215.  
  216.     DWORD    dwFlags;
  217.     HDC        hdc;
  218.  
  219.  
  220.     uint32 *Address32(int x, int y) const {
  221.         return Address32i(x, h-y-1);
  222.     }
  223.  
  224.     uint32 *Address32i(int x, int y) const {
  225.         return (uint32 *)((char *)data + y*pitch + x*4);
  226.     }
  227.  
  228.     void AlignTo4() {
  229.         pitch = w << 2;
  230.     }
  231.  
  232.     void AlignTo8() {
  233.         pitch = ((w+1)&~1) << 2;
  234.     }
  235. };
  236.  
  237. // FilterActivation: This is what is actually passed to filters at runtime.
  238.  
  239. class FilterActivation {
  240. public:
  241.     FilterDefinition *filter;
  242.     void *filter_data;
  243.     VFBitmap &dst, &src;
  244.     VFBitmap *__reserved0, *const last;
  245.     unsigned long x1, y1, x2, y2;
  246.  
  247.     FilterStateInfo *pfsi;
  248.     IFilterPreview *ifp;
  249.     IVDFilterPreview2 *ifp2;    // (V11+)
  250.  
  251.     FilterActivation(VFBitmap& _dst, VFBitmap& _src, VFBitmap *_last) : dst(_dst), src(_src), last(_last) {}
  252.     FilterActivation(const FilterActivation& fa, VFBitmap& _dst, VFBitmap& _src, VFBitmap *_last);
  253. };
  254.  
  255. // These flags must match those in cpuaccel.h!
  256.  
  257. #ifndef f_VIRTUALDUB_CPUACCEL_H
  258. #define CPUF_SUPPORTS_CPUID            (0x00000001L)
  259. #define CPUF_SUPPORTS_FPU            (0x00000002L)
  260. #define CPUF_SUPPORTS_MMX            (0x00000004L)
  261. #define CPUF_SUPPORTS_INTEGER_SSE    (0x00000008L)
  262. #define CPUF_SUPPORTS_SSE            (0x00000010L)
  263. #define CPUF_SUPPORTS_SSE2            (0x00000020L)
  264. #define CPUF_SUPPORTS_3DNOW            (0x00000040L)
  265. #define CPUF_SUPPORTS_3DNOW_EXT        (0x00000080L)
  266. #endif
  267.  
  268. struct FilterFunctions {
  269.     FilterDefinition *(__cdecl *addFilter)(FilterModule *, FilterDefinition *, int fd_len);
  270.     void (__cdecl *removeFilter)(FilterDefinition *);
  271.     bool (__cdecl *isFPUEnabled)();
  272.     bool (__cdecl *isMMXEnabled)();
  273.     void (__cdecl *InitVTables)(struct FilterVTbls *);
  274.  
  275.     // These functions permit you to throw MyError exceptions from a filter.
  276.     // YOU MUST ONLY CALL THESE IN runProc, initProc, and startProc.
  277.  
  278.     void (__cdecl *ExceptOutOfMemory)();                        // ADDED: V6 (VirtualDub 1.4)
  279.     void (__cdecl *Except)(const char *format, ...);            // ADDED: V6 (VirtualDub 1.4)
  280.  
  281.     // These functions are callable at any time.
  282.  
  283.     long (__cdecl *getCPUFlags)();                                // ADDED: V6 (VirtualDub 1.4)
  284.     long (__cdecl *getHostVersionInfo)(char *buffer, int len);    // ADDED: V7 (VirtualDub 1.4d)
  285. };
  286.  
  287.  
  288.  
  289.  
  290.  
  291. ///////////////////////////////////////////////////////////////////////////
  292.  
  293. class CScriptValue;
  294. class CScriptError;
  295. struct CScriptObject;
  296.  
  297. class IScriptInterpreter {
  298. public:
  299.     virtual    void _placeholder1() {}
  300.     virtual void _placeholder2(void *, void *) {}
  301.     virtual void _placeholder3(char *s) {}
  302.  
  303.     virtual void ScriptError(int e)=0;
  304.     virtual void _placeholder4(CScriptError& cse) {}
  305.     virtual char** AllocTempString(long l)=0;
  306.  
  307.     virtual void _placeholder5() {}
  308. };
  309.  
  310. #define EXT_SCRIPT_ERROR(x)    (isi->ScriptError((CScriptError::x)))
  311.  
  312. typedef CScriptValue (*ScriptFunctionPtr)(IScriptInterpreter *, void *, const CScriptValue *, int);
  313. typedef void (*ScriptVoidFunctionPtr)(IScriptInterpreter *, void *, const CScriptValue *, int);
  314. typedef int (*ScriptIntFunctionPtr)(IScriptInterpreter *, void *, const CScriptValue *, int);
  315.  
  316. typedef struct ScriptFunctionDef {
  317.     ScriptFunctionPtr func_ptr;
  318.     char *name;
  319.     char *arg_list;
  320. } ScriptFunctionDef;
  321.  
  322. typedef struct ScriptObjectDef {
  323.     char *name;
  324.     CScriptObject *obj;
  325. } ScriptObjectDef;
  326.  
  327. typedef struct CScriptObject {
  328.     void *_lookup;
  329.     ScriptFunctionDef        *func_list;
  330.     ScriptObjectDef            *obj_list;
  331. } CScriptObject;
  332.  
  333. class CScriptValue {
  334. public:
  335.     enum { T_VOID, T_INT, T_PINT, T_STR, T_ARRAY, T_OBJECT, T_FNAME, T_FUNCTION, T_VARLV, T_LONG, T_DOUBLE } type;
  336.     CScriptObject *thisPtr;
  337.     union {
  338.         int i;
  339.         char **s;
  340.         sint64 l;
  341.         double d;
  342.     } u;
  343.  
  344.     CScriptValue()                        { type = T_VOID; }
  345.     CScriptValue(int i)                    { type = T_INT;            u.i = i; }
  346.     CScriptValue(sint64 l)                { type = T_LONG;        u.l = l; }
  347.     CScriptValue(double d)                { type = T_DOUBLE;        u.d = d; }
  348.     CScriptValue(char **s)                { type = T_STR;            u.s = s; }
  349.  
  350.     bool isVoid() const                    { return type == T_VOID; }
  351.     bool isInt() const                    { return type == T_INT; }
  352.     bool isString() const                { return type == T_STR; }
  353.     bool isLong() const                    { return type == T_LONG; }
  354.     bool isDouble() const                { return type == T_DOUBLE; }
  355.  
  356.     int        asInt() const                { return u.i; }
  357.     sint64    asLong() const                { return u.l; }
  358.     double    asDouble() const            { return u.d; }
  359.     char **    asString() const             { return u.s; }
  360. };
  361.  
  362.  
  363.  
  364.  
  365. #endif
  366.